home *** CD-ROM | disk | FTP | other *** search
/ EnigmA Amiga Run 1995 November / EnigmA AMIGA RUN 02 (1995)(G.R. Edizioni)(IT)[!][issue 1995-11][Skylink CD].iso / earcd / ear / mui23dev.lha / MUI / Developer / Modula / txt / MuiMacros.mod < prev    next >
Text File  |  1994-06-29  |  33KB  |  1,004 lines
  1. IMPLEMENTATION MODULE MuiMacros;
  2.  
  3. (*$ NilChk      := FALSE EntryClear  := FALSE LargeVars   := FALSE StackParms  := FALSE *)
  4. (*$ DEFINE Locale :=FALSE *)
  5. (*$ DEFINE MUIObsolete :=FALSE *)
  6.  
  7. (****************************************************************************
  8. **
  9. **      MUI Macros 2.0
  10. **
  11. **      Converted to Modula by Christian "Kochtopf" Scholz
  12. **
  13. **      $Id: MuiMacros.mod,v 1.6 1994/06/27 22:06:41 Kochtopf Exp Kochtopf $
  14. **
  15. **      $Log: MuiMacros.mod,v $
  16. # Revision 1.6  1994/06/27  22:06:41  Kochtopf
  17. # put some Macros in MUIObsolete-Parenthesis, because one should
  18. # now use mMakeObj.
  19. #
  20. # Revision 1.5  1994/02/15  21:14:05  Kochtopf
  21. # neue Macros fuer Pop* und Register definiert,
  22. # HCenter und VCenter neu
  23. # PopUp entfernt und durch PopButton ersetzt.
  24. # neue Label-Macros LLabel eingefuehrt (aus mui.h)
  25. #
  26. # Revision 1.4  1994/02/09  14:50:03  Kochtopf
  27. # Versionsnummer in 2.0 geaendert.
  28. #
  29. **
  30. ****************************************************************************)
  31.  
  32. IMPORT  MD:MuiD;
  33. IMPORT  ML:MuiL;
  34. IMPORT  UD:UtilityD;
  35. IMPORT  R;
  36. FROM    MuiSupport IMPORT DoMethod;
  37. FROM    UtilityD IMPORT tagEnd, tagMore, HookPtr, Hook;
  38. FROM    SYSTEM IMPORT ADDRESS, ADR, TAG, CAST, SETREG, REG;
  39. FROM    IntuitionL IMPORT SetAttrsA, GetAttr;
  40. FROM    IntuitionD IMPORT omGET, omADDMEMBER, omREMMEMBER;
  41. FROM    Storage IMPORT ALLOCATE;
  42.  
  43. VAR buffer  : ARRAY [0..50] OF LONGINT;      (* for the tags *)
  44.  
  45. (*{{{  "MUI-Object-Generation" *)
  46. (*
  47. **
  48. **  MUI - Object Generation
  49. **
  50. *)
  51.  
  52. PROCEDURE WindowObject(tags : UD.TagItemPtr) : APTR;
  53.     BEGIN
  54.         RETURN ML.mNewObject(ADR(MD.mcWindow), tags);
  55.     END WindowObject;
  56.  
  57. PROCEDURE ImageObject(tags : UD.TagItemPtr) : APTR;
  58.     BEGIN
  59.         RETURN ML.mNewObject(ADR(MD.mcImage), tags);
  60.     END ImageObject;
  61.  
  62. PROCEDURE ApplicationObject(tags : UD.TagItemPtr) : APTR;
  63.     BEGIN
  64.         RETURN ML.mNewObject(ADR(MD.mcApplication), tags);
  65.     END ApplicationObject;
  66.  
  67. PROCEDURE NotifyObject(tags : UD.TagItemPtr) : APTR;
  68.     BEGIN
  69.         RETURN ML.mNewObject(ADR(MD.mcNotify), tags);
  70.     END NotifyObject;
  71.  
  72. PROCEDURE TextObject(tags : UD.TagItemPtr) : APTR;
  73.     BEGIN
  74.         RETURN ML.mNewObject(ADR(MD.mcText), tags);
  75.     END TextObject;
  76.  
  77. PROCEDURE RectangleObject(tags : UD.TagItemPtr) : APTR;
  78.     BEGIN
  79.         RETURN ML.mNewObject(ADR(MD.mcRectangle), tags);
  80.     END RectangleObject;
  81.  
  82. PROCEDURE ListObject(tags : UD.TagItemPtr) : APTR;
  83.     BEGIN
  84.         RETURN ML.mNewObject(ADR(MD.mcList), tags);
  85.     END ListObject;
  86.  
  87. PROCEDURE PropObject(tags : UD.TagItemPtr) : APTR;
  88.     BEGIN
  89.         RETURN ML.mNewObject(ADR(MD.mcProp), tags);
  90.     END PropObject;
  91.  
  92. PROCEDURE StringObject(tags : UD.TagItemPtr) : APTR;
  93.     BEGIN
  94.         RETURN ML.mNewObject(ADR(MD.mcString), tags);
  95.     END StringObject;
  96.  
  97. PROCEDURE ScrollbarObject(tags : UD.TagItemPtr) : APTR;
  98.     BEGIN
  99.         RETURN ML.mNewObject(ADR(MD.mcScrollbar), tags);
  100.     END ScrollbarObject;
  101.  
  102. PROCEDURE ListviewObject(tags : UD.TagItemPtr) : APTR;
  103.     BEGIN
  104.         RETURN ML.mNewObject(ADR(MD.mcListview), tags);
  105.     END ListviewObject;
  106.  
  107. PROCEDURE RadioObject(tags : UD.TagItemPtr) : APTR;
  108.     BEGIN
  109.         RETURN ML.mNewObject(ADR(MD.mcRadio), tags);
  110.     END RadioObject;
  111.  
  112. PROCEDURE VolumelistObject(tags : UD.TagItemPtr) : APTR;
  113.     BEGIN
  114.         RETURN ML.mNewObject(ADR(MD.mcVolumelist), tags);
  115.     END VolumelistObject;
  116.  
  117. PROCEDURE FloattextObject(tags : UD.TagItemPtr) : APTR;
  118.     BEGIN
  119.         RETURN ML.mNewObject(ADR(MD.mcFloattext), tags);
  120.     END FloattextObject;
  121.  
  122. PROCEDURE DirlistObject(tags : UD.TagItemPtr) : APTR;
  123.     BEGIN
  124.         RETURN ML.mNewObject(ADR(MD.mcDirlist), tags);
  125.     END DirlistObject;
  126.  
  127. PROCEDURE ScrmodelistObject(tags : UD.TagItemPtr) : APTR;
  128.     BEGIN
  129.         RETURN ML.mNewObject(ADR(MD.mcScrmodelist), tags);
  130.     END ScrmodelistObject;
  131.  
  132. PROCEDURE SliderObject(tags : UD.TagItemPtr) : APTR;
  133.     BEGIN
  134.         RETURN ML.mNewObject(ADR(MD.mcSlider), tags);
  135.     END SliderObject;
  136.  
  137. PROCEDURE CycleObject(tags : UD.TagItemPtr) : APTR;
  138.     BEGIN
  139.         RETURN ML.mNewObject(ADR(MD.mcCycle), tags);
  140.     END CycleObject;
  141.  
  142. PROCEDURE GaugeObject(tags : UD.TagItemPtr) : APTR;
  143.     BEGIN
  144.         RETURN ML.mNewObject(ADR(MD.mcGauge), tags);
  145.     END GaugeObject;
  146.  
  147. PROCEDURE BoopsiObject(tags : UD.TagItemPtr) : APTR;
  148.     BEGIN
  149.         RETURN ML.mNewObject(ADR(MD.mcBoopsi), tags);
  150.     END BoopsiObject;
  151.  
  152. PROCEDURE ScaleObject(tags : UD.TagItemPtr) : APTR;
  153.     BEGIN
  154.         RETURN ML.mNewObject(ADR(MD.mcScale), tags);
  155.     END ScaleObject;
  156.  
  157. PROCEDURE GroupObject(tags : UD.TagItemPtr) : APTR;
  158.     BEGIN
  159.         RETURN ML.mNewObject(ADR(MD.mcGroup), tags);
  160.     END GroupObject;
  161.  
  162. PROCEDURE VGroup(tags : UD.TagItemPtr) : APTR;
  163.     BEGIN
  164.         RETURN ML.mNewObject(ADR(MD.mcGroup), tags);
  165.     END VGroup;
  166.  
  167. PROCEDURE HGroup(tags : UD.TagItemPtr) : APTR;
  168.     BEGIN
  169.         RETURN ML.mNewObject(ADR(MD.mcGroup), TAG(buffer, MD.maGroupHoriz, TRUE, tagMore, tags, tagEnd));
  170.     END HGroup;
  171.  
  172. PROCEDURE ColGroup(cols : LONGCARD; tags : UD.TagItemPtr) : APTR;
  173.     BEGIN
  174.         RETURN ML.mNewObject(ADR(MD.mcGroup), TAG(buffer, MD.maGroupColumns, cols, tagMore, tags, tagEnd));
  175.     END ColGroup;
  176.  
  177. PROCEDURE RowGroup(rows : LONGCARD; tags : UD.TagItemPtr) : APTR;
  178.     BEGIN
  179.         RETURN ML.mNewObject(ADR(MD.mcGroup), TAG(buffer, MD.maGroupRows, rows, tagMore, tags, tagEnd));
  180.     END RowGroup;
  181.  
  182. PROCEDURE PageGroup(tags : UD.TagItemPtr) : APTR;
  183.     BEGIN
  184.          RETURN ML.mNewObject(ADR(MD.mcGroup),TAG(buffer, MD.maGroupPageMode, TRUE, tagMore, tags, tagEnd));
  185.     END PageGroup;
  186.  
  187. PROCEDURE ColorfieldObject(tags : UD.TagItemPtr) : APTR;
  188.     BEGIN
  189.          RETURN ML.mNewObject(ADR(MD.mcColorfield), tags);
  190.     END ColorfieldObject;
  191.  
  192. PROCEDURE ColoradjustObject(tags : UD.TagItemPtr) : APTR;
  193.     BEGIN
  194.          RETURN ML.mNewObject(ADR(MD.mcColoradjust), tags);
  195.     END ColoradjustObject;
  196.  
  197. PROCEDURE PaletteObject(tags : UD.TagItemPtr) : APTR;
  198.     BEGIN
  199.          RETURN ML.mNewObject(ADR(MD.mcPalette), tags);
  200.     END PaletteObject;
  201.  
  202. PROCEDURE VirtgroupObject(tags : UD.TagItemPtr) : APTR;
  203.     BEGIN
  204.          RETURN ML.mNewObject(ADR(MD.mcVirtgroup), tags);
  205.     END VirtgroupObject;
  206.  
  207. PROCEDURE ScrollgroupObject(tags : UD.TagItemPtr) : APTR;
  208.     BEGIN
  209.          RETURN ML.mNewObject(ADR(MD.mcScrollgroup), tags);
  210.     END ScrollgroupObject;
  211.  
  212. PROCEDURE VGroupV(tags : UD.TagItemPtr) : APTR;
  213.     BEGIN
  214.          RETURN ML.mNewObject(ADR(MD.mcVirtgroup), tags);
  215.     END VGroupV;
  216.  
  217. PROCEDURE HGroupV(tags : UD.TagItemPtr) : APTR;
  218.     BEGIN
  219.         RETURN ML.mNewObject(ADR(MD.mcVirtgroup), TAG(buffer, MD.maGroupHoriz, TRUE, tagMore, tags, tagEnd));
  220.     END HGroupV;
  221.  
  222. PROCEDURE ColGroupV(cols : LONGCARD; tags : UD.TagItemPtr) : APTR;
  223.     BEGIN
  224.         RETURN ML.mNewObject(ADR(MD.mcVirtgroup), TAG(buffer, MD.maGroupColumns, cols, tagMore, tags, tagEnd));
  225.     END ColGroupV;
  226.  
  227. PROCEDURE RowGroupV(rows : LONGCARD; tags : UD.TagItemPtr) : APTR;
  228.     BEGIN
  229.         RETURN ML.mNewObject(ADR(MD.mcVirtgroup), TAG(buffer, MD.maGroupRows, rows, tagMore, tags, tagEnd));
  230.     END RowGroupV;
  231.  
  232. PROCEDURE PageGroupV(tags : UD.TagItemPtr) : APTR;
  233.     BEGIN
  234.          RETURN ML.mNewObject(ADR(MD.mcVirtgroup),TAG(buffer, MD.maGroupPageMode, TRUE, tagMore, tags, tagEnd));
  235.     END PageGroupV;
  236.  
  237. PROCEDURE PopString(tags : UD.TagItemPtr) : APTR;
  238.     BEGIN
  239.          RETURN ML.mNewObject(ADR(MD.mcPopstring), tags);
  240.     END PopString;
  241.  
  242. PROCEDURE PopObject(tags : UD.TagItemPtr) : APTR;
  243.     BEGIN
  244.          RETURN ML.mNewObject(ADR(MD.mcPopobject), tags);
  245.     END PopObject;
  246.  
  247. PROCEDURE PopAsl(tags : UD.TagItemPtr) : APTR;
  248.     BEGIN
  249.          RETURN ML.mNewObject(ADR(MD.mcPopasl), tags);
  250.     END PopAsl;
  251.  
  252. PROCEDURE Register(tags : UD.TagItemPtr) : APTR;
  253.     BEGIN
  254.          RETURN ML.mNewObject(ADR(MD.mcRegister), tags);
  255.     END Register;
  256.  
  257. (*}}}*)
  258. (*{{{  "MakeID" *)
  259. (*
  260. **  MakeID
  261. **  Generate an ID out of a 4-char-string.
  262. **  Use it the as WindowID ! (look in MuiTest for an example!)
  263. *)
  264.  
  265. PROCEDURE MakeID (name : ShortString): LONGINT;
  266.  
  267.     BEGIN
  268.         RETURN ORD(name[0])+
  269.                ORD(name[1])*256+
  270.                ORD(name[2])*65536+
  271.                ORD(name[3])*16777216;
  272.     END MakeID;
  273. (*}}}*)
  274. (*{{{  "Hook-Support" *)
  275. (*
  276. **  Hook-Support functions
  277. **  1. the dispatcher
  278. **  2. the MakeHook-Function
  279. **
  280. *)
  281.  
  282. PROCEDURE HookEntry(hook{R.A0}  : HookPtr;
  283.                     object{R.A2}: ADDRESS;
  284.                     args{R.A1}  : ADDRESS)     : ADDRESS;
  285.     (*$SaveA4:=TRUE*)
  286.     BEGIN
  287.         SETREG (R.A4, hook^.data);
  288.         RETURN CAST(HookDef,hook^.subEntry)(hook, object, args);
  289.     END HookEntry;
  290.  
  291. PROCEDURE MakeHook(entry:HookDef; VAR hook : HookPtr);
  292.  
  293.     BEGIN
  294.             ALLOCATE(hook,SIZE(Hook));
  295.             hook^.node.succ  := NIL;
  296.             hook^.node.pred  := NIL;
  297.             hook^.entry      := HookEntry;
  298.             hook^.subEntry   := CAST(ADDRESS,entry);
  299.             hook^.data       := REG(R.A4);
  300.     END MakeHook;
  301. (*}}}*)
  302. (*{{{  "Spacing-Macros" *)
  303. (*
  304. **
  305. **  Spacing Macros
  306. **
  307. *)
  308. (*{{{  "HV-Space" *)
  309. PROCEDURE HVSpace() : APTR;
  310.     BEGIN
  311.         RETURN ML.mNewObject(ADR(MD.mcRectangle), NIL);
  312.     END HVSpace;
  313. (*}}}*)
  314. (*{{{  "Hspace" *)
  315. PROCEDURE HSpace(x : LONGCARD) : APTR;
  316.     BEGIN
  317.         IF x#0 THEN 
  318.                 RETURN ML.mNewObject(ADR(MD.mcRectangle),
  319.                                      TAG(buffer,
  320.                                         MD.maFixWidth,     x,
  321.                                         MD.maVertWeight,   0,
  322.                                         tagEnd));
  323.                 ELSE   
  324.                 RETURN ML.mNewObject(ADR(MD.mcRectangle),
  325.                                      TAG(buffer,
  326.                                         MD.maVertWeight,   0,
  327.                                         tagEnd));
  328.                 END;
  329.     END HSpace;
  330. (*}}}*)
  331. (*{{{  "VSpace" *)
  332. PROCEDURE VSpace(x : LONGCARD) : APTR;
  333.     BEGIN
  334.         IF x#0 THEN 
  335.                 RETURN ML.mNewObject(ADR(MD.mcRectangle),
  336.                                      TAG(buffer,
  337.                                         MD.maFixHeight,     x,
  338.                                         MD.maHorizWeight,   0,
  339.                                         tagEnd));
  340.                 ELSE
  341.                 RETURN ML.mNewObject(ADR(MD.mcRectangle),
  342.                                      TAG(buffer,
  343.                                         MD.maHorizWeight,   0,
  344.                                         tagEnd));
  345.                 END;
  346.     END VSpace;
  347. (*}}}*)
  348. (*{{{  "HCenter" *)
  349. PROCEDURE HCenter(obj : APTR) : APTR;
  350.     BEGIN
  351.         RETURN HGroup(TAG(buffer,
  352.                     MD.maGroupSpacing,      0,
  353.                     Child,                  HSpace(0),
  354.                     Child,                  obj,
  355.                     Child,                  HSpace(0),
  356.                     tagEnd));
  357.     END HCenter;
  358. (*}}}*)
  359. (*{{{  "VCenter" *)
  360. PROCEDURE VCenter(obj : APTR) : APTR;
  361.     BEGIN
  362.         RETURN VGroup(TAG(buffer,
  363.                     MD.maGroupSpacing,      0,
  364.                     Child,                  VSpace(0),
  365.                     Child,                  obj,
  366.                     Child,                  VSpace(0),
  367.                     tagEnd));
  368.     END VCenter;
  369. (*}}}*)
  370. (*}}}*)
  371. (*{{{  "PopButton" *)
  372. (*
  373. **
  374. **  PopUp-Button
  375. **
  376. **  to be used for Popup-Objects
  377. **
  378. *)
  379.  
  380. PROCEDURE PopButton(img : ARRAY OF CHAR) : APTR;
  381.     BEGIN
  382.         RETURN ImageObject(TAG(buffer,
  383.                     MD.maFrame,                 MD.mvFrameImageButton,
  384.                     MD.maImageSpec,             ADR(img),
  385.                     MD.maImageFontMatchWidth,   TRUE,
  386.                     MD.maImageFreeVert,         TRUE,
  387.                     MD.maInputMode,             MD.mvInputModeRelVerify,
  388.                     MD.maBackground,            MD.miBACKGROUND,
  389.                     tagEnd));
  390.     END PopButton;
  391. (*}}}*)
  392.  
  393. (*$ IF MUIObsolete *)
  394.  
  395. (*
  396. **
  397. ** String-Object
  398. **
  399. ** Makes a simple String-Gadget
  400. **
  401. *)
  402.  
  403. (*{{{  "StringObjects" *)
  404. (*$ IF Locale *)
  405. PROCEDURE String(contents : StrPtr; maxlen : LONGINT) : APTR;
  406. (*$ ELSE *)(*$ CopyDyn := FALSE *)
  407. PROCEDURE String(contents : ARRAY OF CHAR; maxlen : LONGINT) : APTR;
  408. (*$ ENDIF *)
  409.     BEGIN
  410.         RETURN StringObject(TAG(buffer,
  411.                             MD.maFrame,            MD.mvFrameString,
  412.                             MD.maStringMaxLen,     maxlen,
  413.                             (*$ IF Locale *)
  414.                                 MD.maStringContents,   contents,
  415.                             (*$ ELSE *)
  416.                                 MD.maStringContents,   ADR(contents),
  417.                             (*$ ENDIF *)
  418.                             tagEnd));
  419.     END String;
  420. (*$ IF Locale *)
  421. PROCEDURE KeyString(contents : StrPtr; maxlen : LONGINT; key : CHAR) : APTR;
  422. (*$ ELSE *)(*$ CopyDyn := FALSE *)
  423. PROCEDURE KeyString(contents : ARRAY OF CHAR; maxlen : LONGINT; key : CHAR) : APTR;
  424. (*$ ENDIF *)
  425.     BEGIN
  426.         RETURN StringObject(TAG(buffer,
  427.                             MD.maFrame,             MD.mvFrameString,
  428.                             MD.maStringMaxLen,      maxlen,
  429.                             (*$ IF Locale *)
  430.                                 MD.maStringContents,    contents,
  431.                             (*$ ELSE *)
  432.                                 MD.maStringContents,    ADR(contents),
  433.                             (*$ ENDIF *)
  434.                             MD.maControlChar,       key,
  435.                             tagEnd));
  436.     END KeyString;
  437. (*}}}*)
  438.  
  439. (*
  440. **
  441. ** Checkmark
  442. **
  443. *)
  444.  
  445. (*{{{  "Checkmarks" *)
  446. PROCEDURE Checkmark(selected : BOOLEAN) : APTR;
  447.     BEGIN
  448.         RETURN ImageObject( TAG(buffer,
  449.                             MD.maFrame,            MD.mvFrameImageButton,
  450.                             MD.maInputMode,        MD.mvInputModeToggle,
  451.                             MD.maImageSpec,        MD.miCheckMark,
  452.                             MD.maImageFreeVert,    TRUE,
  453.                             MD.maSelected,         selected,
  454.                             MD.maBackground,       MD.miButtonBack,
  455.                             MD.maShowSelState,     FALSE,
  456.                             tagEnd));
  457.     END Checkmark;
  458.  
  459. PROCEDURE KeyCheckmark(selected : BOOLEAN; key : CHAR) : APTR;
  460.     BEGIN
  461.         RETURN ImageObject( TAG(buffer,
  462.                             MD.maFrame,            MD.mvFrameImageButton,
  463.                             MD.maInputMode,        MD.mvInputModeToggle,
  464.                             MD.maImageSpec,        MD.miCheckMark,
  465.                             MD.maImageFreeVert,    TRUE,
  466.                             MD.maSelected,         selected,
  467.                             MD.maBackground,       MD.miButtonBack,
  468.                             MD.maShowSelState,     FALSE,
  469.                             MD.maControlChar,      key,
  470.                             tagEnd));
  471.     END KeyCheckmark;
  472.  
  473. (*}}}*)
  474.  
  475. (*
  476. **
  477. ** Buttons
  478. **
  479. *)
  480.  
  481. (*{{{  "Buttons" *)
  482. (*$ IF Locale *)
  483. PROCEDURE Simplebutton(name : StrPtr) : APTR;
  484. (*$ ELSE *)(*$ CopyDyn := FALSE *)
  485. PROCEDURE Simplebutton(name : ARRAY OF CHAR) : APTR;
  486. (*$ ENDIF *)
  487.     BEGIN
  488.         RETURN TextObject(  TAG(buffer,
  489.                             MD.maFrame,            MD.mvFrameButton,
  490.                             (*$ IF Locale *)
  491.                                 MD.maTextContents,     name,
  492.                             (*$ ELSE *)
  493.                                 MD.maTextContents,     ADR(name),
  494.                             (*$ ENDIF *)
  495.                             MD.maTextPreParse,     ADR("\033c"),
  496.                             MD.maTextSetMax,       FALSE,
  497.                             MD.maInputMode,        MD.mvInputModeRelVerify,
  498.                             MD.maBackground,       MD.miButtonBack,
  499.                             tagEnd));
  500.  
  501.     END Simplebutton;
  502.  
  503. (*$ IF Locale *)
  504. PROCEDURE Keybutton(name : StrPtr; key : CHAR) : APTR;
  505. (*$ ELSE *)(*$ CopyDyn := FALSE *)
  506. PROCEDURE Keybutton(name : ARRAY OF CHAR; key : CHAR) : APTR;
  507. (*$ ENDIF *)
  508.     BEGIN
  509.         RETURN TextObject(  TAG(buffer,
  510.                             MD.maFrame,            MD.mvFrameButton,
  511.                             (*$ IF Locale *)
  512.                                 MD.maTextContents,     name,
  513.                             (*$ ELSE *)
  514.                                 MD.maTextContents,     ADR(name),
  515.                             (*$ ENDIF *)
  516.                             MD.maTextPreParse,     ADR("\033c"),
  517.                             MD.maTextSetMax,       FALSE,
  518.                             MD.maTextHiChar,       key,
  519.                             MD.maControlChar,      key,
  520.                             MD.maInputMode,        MD.mvInputModeRelVerify,
  521.                             MD.maBackground,       MD.miButtonBack,
  522.                             tagEnd));
  523.  
  524.     END Keybutton;
  525.  
  526. (*}}}*)
  527.  
  528. (*
  529. **
  530. **  Radio Object
  531. **
  532. *)
  533.  
  534. (*{{{  "RadioObjects" *)
  535. (*$ IF Locale *)
  536. PROCEDURE Radio(name : StrPtr; array : APTR) : APTR;
  537. (*$ ELSE *)(*$ CopyDyn := FALSE *)
  538. PROCEDURE Radio(name : ARRAY OF CHAR; array : APTR) : APTR;
  539. (*$ ENDIF *)
  540.     BEGIN
  541.         RETURN RadioObject( TAG(buffer,
  542.                             MD.maFrame,             MD.mvFrameGroup,
  543.                             (*$ IF Locale *)
  544.                                 MD.maFrameTitle,        name,
  545.                             (*$ ELSE *)
  546.                                 MD.maFrameTitle,        ADR(name),
  547.                             (*$ ENDIF *)
  548.                             MD.maRadioEntries,      array,
  549.                             tagEnd));
  550.     END Radio;
  551.  
  552. (*$ IF Locale *)
  553. PROCEDURE KeyRadio(name : StrPtr; array : APTR; key : CHAR) : APTR;
  554. (*$ ELSE *)(*$ CopyDyn := FALSE *)
  555. PROCEDURE KeyRadio(name : ARRAY OF CHAR; array : APTR; key : CHAR) : APTR;
  556. (*$ ENDIF *)
  557.     BEGIN
  558.         RETURN RadioObject( TAG(buffer,
  559.                             MD.maFrame,             MD.mvFrameGroup,
  560.                             (*$ IF Locale *)
  561.                                 MD.maFrameTitle,        name,
  562.                             (*$ ELSE *)
  563.                                 MD.maFrameTitle,        ADR(name),
  564.                             (*$ ENDIF *)
  565.                             MD.maTextHiChar,        key,
  566.                             MD.maControlChar,       key,
  567.                             MD.maRadioEntries,      array,
  568.                             tagEnd));
  569.     END KeyRadio;
  570.  
  571. (*}}}*)
  572.  
  573. (*
  574. **
  575. **  Cycle-Objects
  576. **
  577. *)
  578.  
  579. (*{{{  "Cycle" *)
  580. PROCEDURE Cycle(array : APTR) : APTR;
  581.     BEGIN
  582.         RETURN CycleObject(TAG(buffer,
  583.                             MD.maCycleEntries,      array,
  584.                             tagEnd));
  585.     END Cycle;
  586.  
  587.  
  588. PROCEDURE KeyCycle(array : APTR; key : CHAR) : APTR;
  589.     BEGIN
  590.         RETURN CycleObject(TAG(buffer,
  591.                             MD.maCycleEntries,      array,
  592.                             MD.maControlChar,       key,
  593.                             tagEnd));
  594.     END KeyCycle;
  595. (*}}}*)
  596.  
  597. (*
  598. **
  599. **  Slider-Objects
  600. **
  601. *)
  602.  
  603. (*{{{  "Slider" *)
  604. PROCEDURE Slider(min,max,level : LONGINT; horiz : BOOLEAN) : APTR;
  605.     BEGIN
  606.         RETURN SliderObject(TAG(buffer,
  607.                             MD.maGroupHoriz,        horiz,
  608.                             MD.maSliderLevel,       level,
  609.                             MD.maSliderMax,         max,
  610.                             MD.maSliderMin,         min,
  611.                             tagEnd));
  612.     END Slider;
  613.  
  614. PROCEDURE KeySlider(min,max,level : LONGINT; horiz : BOOLEAN;
  615.                         key : CHAR) : APTR;
  616.     BEGIN
  617.         RETURN SliderObject(TAG(buffer,
  618.                             MD.maGroupHoriz,        horiz,
  619.                             MD.maSliderLevel,       level,
  620.                             MD.maSliderMax,         max,
  621.                             MD.maSliderMin,         min,
  622.                             MD.maControlChar,       key,
  623.                             tagEnd));
  624.     END KeySlider;
  625. (*}}}*)
  626.  
  627. (*$ ELSE *) (* MUIObsolete *)
  628. (*{{{  "alternativer Simplebutton" *)
  629. (*$ IF Locale *)
  630. PROCEDURE Simplebutton(name : StrPtr) : APTR;
  631. (*$ ELSE *)(*$ CopyDyn := FALSE *)
  632. PROCEDURE Simplebutton(name : ARRAY OF CHAR) : APTR;
  633. (*$ ENDIF *)
  634.     BEGIN
  635.         RETURN TextObject(  TAG(buffer,
  636.                             MD.maFrame,            MD.mvFrameButton,
  637.                             (*$ IF Locale *)
  638.                                 MD.maTextContents,     name,
  639.                             (*$ ELSE *)
  640.                                 MD.maTextContents,     ADR(name),
  641.                             (*$ ENDIF *)
  642.                             MD.maTextPreParse,     ADR("\033c"),
  643.                             MD.maTextSetMax,       FALSE,
  644.                             MD.maInputMode,        MD.mvInputModeRelVerify,
  645.                             MD.maBackground,       MD.miButtonBack,
  646.                             tagEnd));
  647.     END Simplebutton;
  648. (*}}}*)
  649. (*$ ENDIF *) (* MUIObsolete *)
  650.  
  651. (*
  652. **
  653. ** Label Objects
  654. **
  655. *)
  656.  
  657. (*{{{  "LabelX" *)
  658. (*$ IF Locale *)
  659. PROCEDURE Label(label : StrPtr) : APTR;
  660. (*$ ELSE *)(*$ CopyDyn := FALSE *)
  661. PROCEDURE Label(label : ARRAY OF CHAR) : APTR;
  662. (*$ ENDIF *)
  663.     BEGIN
  664.         RETURN TextObject(  TAG(buffer,
  665.                             MD.maTextPreParse,         ADR("\033r"),
  666.                             (*$ IF Locale *)
  667.                                 MD.maTextContents,         label,
  668.                             (*$ ELSE *)
  669.                                 MD.maTextContents,         ADR(label),
  670.                             (*$ ENDIF *)
  671.                             MD.maWeight,               0,
  672.                             MD.maInnerLeft,            0,
  673.                             MD.maInnerRight,           0,
  674.                             tagEnd));
  675.     END Label;
  676.  
  677. (*$ IF Locale *)
  678. PROCEDURE Label1(label : StrPtr) : APTR;
  679. (*$ ELSE *)(*$ CopyDyn := FALSE *)
  680. PROCEDURE Label1(label : ARRAY OF CHAR) : APTR;
  681. (*$ ENDIF *)
  682.     BEGIN
  683.         RETURN TextObject(  TAG(buffer,
  684.                             MD.maTextPreParse,         ADR("\033r"),
  685.                             (*$ IF Locale *)
  686.                                 MD.maTextContents,         label,
  687.                             (*$ ELSE *)
  688.                                 MD.maTextContents,         ADR(label),
  689.                             (*$ ENDIF *)
  690.                             MD.maWeight,               0,
  691.                             MD.maInnerLeft,            0,
  692.                             MD.maInnerRight,           0,
  693.                             MD.maFrame,                MD.mvFrameButton,
  694.                             MD.maFramePhantomHoriz,    TRUE,
  695.                             tagEnd));
  696.     END Label1;
  697.  
  698. (*$ IF Locale *)
  699. PROCEDURE Label2(label : StrPtr) : APTR;
  700. (*$ ELSE *)(*$ CopyDyn := FALSE *)
  701. PROCEDURE Label2(label : ARRAY OF CHAR) : APTR;
  702. (*$ ENDIF *)
  703.     BEGIN
  704.         RETURN TextObject(  TAG(buffer,
  705.                             MD.maTextPreParse,         ADR("\033r"),
  706.                             (*$ IF Locale *)
  707.                                 MD.maTextContents,         label,
  708.                             (*$ ELSE *)
  709.                                 MD.maTextContents,         ADR(label),
  710.                             (*$ ENDIF *)
  711.                             MD.maWeight,               0,
  712.                             MD.maInnerLeft,            0,
  713.                             MD.maInnerRight,           0,
  714.                             MD.maFrame,                MD.mvFrameString,
  715.                             MD.maFramePhantomHoriz,    TRUE,
  716.                             tagEnd));
  717.     END Label2;
  718. (*}}}*)
  719. (*{{{  "LLabelX" *)
  720. (*$ IF Locale *)
  721. PROCEDURE LLabel(label : StrPtr) : APTR;
  722. (*$ ELSE *)(*$ CopyDyn := FALSE *)
  723. PROCEDURE LLabel(label : ARRAY OF CHAR) : APTR;
  724. (*$ ENDIF *)
  725.     BEGIN
  726.         RETURN TextObject(  TAG(buffer,
  727.                             (*$ IF Locale *)
  728.                                 MD.maTextContents,         label,
  729.                             (*$ ELSE *)
  730.                                 MD.maTextContents,         ADR(label),
  731.                             (*$ ENDIF *)
  732.                             MD.maWeight,               0,
  733.                             MD.maInnerLeft,            0,
  734.                             MD.maInnerRight,           0,
  735.                             tagEnd));
  736.     END LLabel;
  737.  
  738.  
  739. (*$ IF Locale *)
  740. PROCEDURE LLabel1(label : StrPtr) : APTR;
  741. (*$ ELSE *)(*$ CopyDyn := FALSE *)
  742. PROCEDURE LLabel1(label : ARRAY OF CHAR) : APTR;
  743. (*$ ENDIF *)
  744.     BEGIN
  745.         RETURN TextObject(  TAG(buffer,
  746.                             (*$ IF Locale *)
  747.                                 MD.maTextContents,         label,
  748.                             (*$ ELSE *)
  749.                                 MD.maTextContents,         ADR(label),
  750.                             (*$ ENDIF *)
  751.                             MD.maWeight,               0,
  752.                             MD.maInnerLeft,            0,
  753.                             MD.maInnerRight,           0,
  754.                             MD.maFrame,                MD.mvFrameButton,
  755.                             MD.maFramePhantomHoriz,    TRUE,
  756.                             tagEnd));
  757.     END LLabel1;
  758.  
  759.  
  760. (*$ IF Locale *)
  761. PROCEDURE LLabel2(label : StrPtr) : APTR;
  762. (*$ ELSE *)(*$ CopyDyn := FALSE *)
  763. PROCEDURE LLabel2(label : ARRAY OF CHAR) : APTR;
  764. (*$ ENDIF *)
  765.     BEGIN
  766.         RETURN TextObject(  TAG(buffer,
  767.                             (*$ IF Locale *)
  768.                                 MD.maTextContents,         label,
  769.                             (*$ ELSE *)
  770.                                 MD.maTextContents,         ADR(label),
  771.                             (*$ ENDIF *)
  772.                             MD.maWeight,               0,
  773.                             MD.maInnerLeft,            0,
  774.                             MD.maInnerRight,           0,
  775.                             MD.maFrame,                MD.mvFrameString,
  776.                             MD.maFramePhantomHoriz,    TRUE,
  777.                             tagEnd));
  778.     END LLabel2;
  779. (*}}}*)
  780. (*{{{  "KeyLabelX" *)
  781. (*$ IF Locale *)
  782. PROCEDURE KeyLabel(label : StrPtr; HiChar : CHAR) : APTR;
  783. (*$ ELSE *)(*$ CopyDyn := FALSE *)
  784. PROCEDURE KeyLabel(label : ARRAY OF CHAR; HiChar : CHAR) : APTR;
  785. (*$ ENDIF *)
  786.     BEGIN
  787.         RETURN TextObject(  TAG(buffer,
  788.                             MD.maTextPreParse,         ADR("\033r"),
  789.                             (*$ IF Locale *)
  790.                                 MD.maTextContents,         label,
  791.                             (*$ ELSE *)
  792.                                 MD.maTextContents,         ADR(label),
  793.                             (*$ ENDIF *)
  794.                             MD.maWeight,               0,
  795.                             MD.maInnerLeft,            0,
  796.                             MD.maInnerRight,           0,
  797.                             MD.maTextHiChar,           HiChar,
  798.                             tagEnd));
  799.     END KeyLabel;
  800.  
  801.  
  802. (*$ IF Locale *)
  803. PROCEDURE KeyLabel1(label : StrPtr; HiChar : CHAR) : APTR;
  804. (*$ ELSE *)(*$ CopyDyn := FALSE *)
  805. PROCEDURE KeyLabel1(label : ARRAY OF CHAR; HiChar : CHAR) : APTR;
  806. (*$ ENDIF *)
  807.     BEGIN
  808.         RETURN TextObject(  TAG(buffer,
  809.                             MD.maTextPreParse,         ADR("\033r"),
  810.                             (*$ IF Locale *)
  811.                                 MD.maTextContents,         label,
  812.                             (*$ ELSE *)
  813.                                 MD.maTextContents,         ADR(label),
  814.                             (*$ ENDIF *)
  815.                             MD.maWeight,               0,
  816.                             MD.maInnerLeft,            0,
  817.                             MD.maInnerRight,           0,
  818.                             MD.maTextHiChar,           HiChar,
  819.                             MD.maFrame,                MD.mvFrameButton,
  820.                             MD.maFramePhantomHoriz,    TRUE,
  821.                             tagEnd));
  822.     END KeyLabel1;
  823.  
  824.  
  825. (*$ IF Locale *)
  826. PROCEDURE KeyLabel2(label : StrPtr; HiChar : CHAR) : APTR;
  827. (*$ ELSE *)(*$ CopyDyn := FALSE *)
  828. PROCEDURE KeyLabel2(label : ARRAY OF CHAR; HiChar : CHAR) : APTR;
  829. (*$ ENDIF *)
  830.     BEGIN
  831.         RETURN TextObject(  TAG(buffer,
  832.                             MD.maTextPreParse,         ADR("\033r"),
  833.                             (*$ IF Locale *)
  834.                                 MD.maTextContents,         label,
  835.                             (*$ ELSE *)
  836.                                 MD.maTextContents,         ADR(label),
  837.                             (*$ ENDIF *)
  838.                             MD.maWeight,               0,
  839.                             MD.maInnerLeft,            0,
  840.                             MD.maInnerRight,           0,
  841.                             MD.maTextHiChar,           HiChar,
  842.                             MD.maFrame,                MD.mvFrameString,
  843.                             MD.maFramePhantomHoriz,    TRUE,
  844.                             tagEnd));
  845.     END KeyLabel2;
  846. (*}}}*)
  847. (*{{{  "KeyLLabelX" *)
  848. (*$ IF Locale *)
  849. PROCEDURE KeyLLabel(label : StrPtr; HiChar : CHAR) : APTR;
  850. (*$ ELSE *)(*$ CopyDyn := FALSE *)
  851. PROCEDURE KeyLLabel(label : ARRAY OF CHAR; HiChar : CHAR) : APTR;
  852. (*$ ENDIF *)
  853.     BEGIN
  854.         RETURN TextObject(  TAG(buffer,
  855.                             (*$ IF Locale *)
  856.                                 MD.maTextContents,         label,
  857.                             (*$ ELSE *)
  858.                                 MD.maTextContents,         ADR(label),
  859.                             (*$ ENDIF *)
  860.                             MD.maWeight,               0,
  861.                             MD.maInnerLeft,            0,
  862.                             MD.maInnerRight,           0,
  863.                             MD.maTextHiChar,           HiChar,
  864.                             tagEnd));
  865.     END KeyLLabel;
  866.  
  867.  
  868. (*$ IF Locale *)
  869. PROCEDURE KeyLLabel1(label : StrPtr; HiChar : CHAR) : APTR;
  870. (*$ ELSE *)(*$ CopyDyn := FALSE *)
  871. PROCEDURE KeyLLabel1(label : ARRAY OF CHAR; HiChar : CHAR) : APTR;
  872. (*$ ENDIF *)
  873.     BEGIN
  874.         RETURN TextObject(  TAG(buffer,
  875.                             (*$ IF Locale *)
  876.                                 MD.maTextContents,         label,
  877.                             (*$ ELSE *)
  878.                                 MD.maTextContents,         ADR(label),
  879.                             (*$ ENDIF *)
  880.                             MD.maWeight,               0,
  881.                             MD.maInnerLeft,            0,
  882.                             MD.maInnerRight,           0,
  883.                             MD.maTextHiChar,           HiChar,
  884.                             MD.maFrame,                MD.mvFrameButton,
  885.                             MD.maFramePhantomHoriz,    TRUE,
  886.                             tagEnd));
  887.     END KeyLLabel1;
  888.  
  889.  
  890. (*$ IF Locale *)
  891. PROCEDURE KeyLLabel2(label : StrPtr; HiChar : CHAR) : APTR;
  892. (*$ ELSE *)(*$ CopyDyn := FALSE *)
  893. PROCEDURE KeyLLabel2(label : ARRAY OF CHAR; HiChar : CHAR) : APTR;
  894. (*$ ENDIF *)
  895.     BEGIN
  896.         RETURN TextObject(  TAG(buffer,
  897.                             (*$ IF Locale *)
  898.                                 MD.maTextContents,         label,
  899.                             (*$ ELSE *)
  900.                                 MD.maTextContents,         ADR(label),
  901.                             (*$ ENDIF *)
  902.                             MD.maWeight,               0,
  903.                             MD.maInnerLeft,            0,
  904.                             MD.maInnerRight,           0,
  905.                             MD.maTextHiChar,           HiChar,
  906.                             MD.maFrame,                MD.mvFrameString,
  907.                             MD.maFramePhantomHoriz,    TRUE,
  908.                             tagEnd));
  909.     END KeyLLabel2;
  910. (*}}}*)
  911.  
  912. (*
  913. **
  914. ** Controlling Objects
  915. **
  916. ** Note : get didn't work in previous releases
  917. **
  918. *)
  919.  
  920. (*{{{  "set, get,...." *)
  921.  
  922. PROCEDURE get(obj : APTR; attr : LONGCARD; store : ADDRESS);
  923.     BEGIN DoMethod(obj,TAG(buffer, omGET, attr, store));
  924.     END get;
  925.  
  926. PROCEDURE set(obj : APTR; attr : LONGCARD; value : LONGINT);
  927.     VAR dummy : APTR;
  928.     BEGIN dummy:=SetAttrsA(obj, TAG(buffer,attr,value,tagEnd));
  929.     END set;
  930.  
  931. PROCEDURE setmutex(obj : APTR; n : LONGINT);
  932.     BEGIN set(obj,MD.maRadioActive,n);
  933.     END setmutex;
  934.  
  935. PROCEDURE setcycle(obj : APTR; n : LONGINT);
  936.     BEGIN set(obj,MD.maCycleActive,n);
  937.     END setcycle;
  938.  
  939. (*$ IF Locale *)
  940. PROCEDURE setstring(obj : APTR; s : StrPtr);
  941.     BEGIN set(obj,MD.maStringContents,s);
  942.     END setstring;
  943. (*$ ELSE *) (*$ CopyDyn := FALSE *)
  944. PROCEDURE setstring(obj : APTR; s : ARRAY OF CHAR);
  945.     BEGIN set(obj,MD.maStringContents,ADR(s));
  946.     END setstring;
  947. (*$ ENDIF *)
  948.  
  949. PROCEDURE setcheckmark(obj : APTR; b : BOOLEAN);
  950.     BEGIN
  951.         IF b THEN set(obj,MD.maSelected,1);
  952.              ELSE set(obj,MD.maSelected,0);
  953.              END;
  954.     END setcheckmark;
  955.  
  956. PROCEDURE setslider(obj : APTR; l : LONGINT);
  957.     BEGIN set(obj,MD.maSliderLevel,l);
  958.     END setslider;
  959.  
  960. (*}}}*)
  961. (*{{{  "NoteClose" *)
  962. (*
  963. ** NoteClose (app,obj,ID)
  964. *)
  965. PROCEDURE NoteClose(app : APTR; obj : APTR; ID  : LONGINT);
  966.     BEGIN DoMethod(obj,TAG(buffer, MD.mmNotify,MD.maWindowCloseRequest,TRUE, app,2,MD.mmApplicationReturnID,ID));
  967.     END NoteClose;
  968. (*}}}*)
  969. (*{{{  "NoteButton" *)
  970. (*
  971. **  Notebutton (app,obj,ID)
  972. *)
  973. PROCEDURE NoteButton(app : APTR; obj : APTR; ID  : LONGINT);
  974.     BEGIN DoMethod(obj,TAG(buffer, MD.mmNotify,MD.maPressed, FALSE, app,2,MD.mmApplicationReturnID,ID));
  975.     END NoteButton;
  976. (*}}}*)
  977. (*{{{  "RemMember" *)
  978. (*
  979. ** RemMember (obj,member)
  980. *)
  981.  
  982. PROCEDURE RemMember(obj : APTR; member : APTR);
  983.     BEGIN DoMethod(obj,TAG(buffer, omREMMEMBER, member));
  984.     END RemMember;
  985. (*}}}*)
  986. (*{{{  "AddMember" *)
  987. (*
  988. ** AddMember (obj,member)
  989. *)
  990.  
  991. PROCEDURE AddMember(obj : APTR; member : APTR);
  992.     BEGIN DoMethod(obj,TAG(buffer, omADDMEMBER, member));
  993.     END AddMember;
  994. (*}}}*)
  995.  
  996. END MuiMacros.
  997.  
  998.  
  999.  
  1000.  
  1001.  
  1002.  
  1003.  
  1004.